// 该文件负责接收前端的请求，进行处理(分发请求)
// async(req,res)  require请求  respond响应
// get使用req.query获取数据   post使用req.body获取数据


// 导入路由
const router = require('express').Router()
// 导入考试数据模型
const examModel = require('../model/examModel')

// ###考试分类

// 添加试卷分类
// 地址：http://127.0.0.1:4000/api/exam/category_add
// 请求：POST (不可以在浏览器地址栏测试)
// 参数：text 
// 示例：http://127.0.0.1:4000/api/exam/category_add
// 响应数据格式: json格式
router.post('/category_add', async (req, res) => {
    // 接收前端提交的参数
    let text = req.body.text;
    // 判断text是否有值
    if (text) {
        // 执行数据库的操作
        await examModel.category_add(text)
            .then(
                data => {
                    // 把模型中的处理结果响应给前端
                    res.send(data);
                }
            )
            .catch(
                error => {
                    res.send(error);
                }
            )
    }
    else {
        // 提示缺少参数
        res.send({
            code: -1,
            msg: "缺少参数，请检查后在提交"
        })
    }
})


// 获取考试分类列表
// 地址：http://127.0.0.1:4000/api/exam/category_list
// 请求：GET (可以在浏览器地址栏测试)
// 参数：无
// 示例：http://127.0.0.1:4000/api/exam/category_list
// 响应数据格式: json格式
router.get('/category_list', async (req, res) => {
    await examModel.category_list()
        .then(
            data => {
                // 响应数据给前端
                res.send(data)
            },
            err => {
                res.send(err);
            }
        )
})


// 删除考试分类名称
// 地址：http://127.0.0.1:4000/api/exam/category_remove
// 请求：GET (可以在浏览器地址栏测试)
// 参数：id
// 示例：http://127.0.0.1:4000/api/exam/category_remove
// 响应数据格式: json格式
router.get('/category_remove', async (req, res) => {
    let id = req.query.id;
    if (id) {
        await examModel.category_remove(id)
            .then(
                data => {
                    // 响应数据给前端
                    res.send(data)
                },
                err => {
                    res.send(err);
                }
            )
    }
    else {
        // 提示缺少参数
        res.send({
            code: -1,
            msg: "缺少参数，请检查后在提交"
        })
    }
})


// 修改考试分类名称
// 地址：http://127.0.0.1:4000/api/exam/category_modify
// 请求：POST (不可以在浏览器地址栏测试)
// 参数：id text
// 示例：http://127.0.0.1:4000/api/exam/category_modify
// 响应数据格式: json格式
router.post('/category_modify', async (req, res) => {
    // 接收前端提交的参数
    let { id, text } = req.body;
    // 判断参数是否有值
    if (id == undefined || text == undefined) {
        res.send({
            code: -1,
            mag: "缺少参数，请检查再提交"
        })
    }
    else {
        // 执行数据库的操作
        await examModel.category_modify(id, text)
            .then(
                data => {
                    // 把模型中的处理结果响应给前端
                    res.send(data);
                }
            )
            .catch(
                error => {
                    res.send(error);
                }
            )
    }
})



// ###试卷

// 新增试卷
// 地址：http://127.0.0.1:4000/api/exam/exam_add
// 请求：POST (不可以在浏览器地址栏测试)
// 参数：id, text, name, total, passline, time
// 示例：http://127.0.0.1:4000/api/exam/exam_add
// 响应数据格式: json格式
router.post('/exam_add', async (req, res) => {
    // 接收前端提交的参数
    let { id, text, name, total, passline, time } = req.body;
    // 判断参数是否有值
    if (text && id && name && total && passline && time) {
        // 执行数据库的操作
        await examModel.exam_add(id, text, name, total, passline, time)
            .then(
                data => {
                    // 把模型中的处理结果响应给前端
                    res.send(data);
                }
            )
            .catch(
                err => {
                    res.send(err);
                }
            )
    }
    else {
        // 提示缺少参数
        res.send({
            code: -1,
            msg: "缺少参数，请检查后再提交"
        })
    }
})

// 获取试卷列表
// 地址：http://127.0.0.1:4000/api/exam/exam_list_all
// 请求：GET (可以在浏览器地址栏测试)
// 参数：无
// 示例：http://127.0.0.1:4000/api/exam/exam_list_all
// 响应数据格式: json格式
router.get('/exam_list_all', async (req, res) => {
    await examModel.exam_list_all()
        .then(
            data => {
                // 响应数据给前端
                res.send(data)
            },
            err => {
                res.send(err);
            }
        )
})


// ## 题目部分
// ## 试卷
// 新增试卷
// 地址：http://127.0.0.1:4000/api/exam/topic_add
// 请求：POST (不可以在浏览器地址栏测试)
// 参数：eid, name, question, answer, score, option
// 示例：http://127.0.0.1:4000/api/exam/topic_add
// 响应数据格式: json格式
router.post('/topic_add', async (req, res) => {
    // 接收前端提交的参数
    let {eid, name, question, answer, score, opt} = req.body;
    // 判断text是否有值
    if (eid && name && question && answer && score && opt) {
        // 执行数据库的操作
        await examModel.topic_add(eid, name, question, answer, score, opt)
            .then(
                data => {
                    // 把模型中的处理结果响应给前端
                    res.send(data);
                }
            )
            .catch(
                err => {
                    res.send(err);
                }
            )
    }
    else {
        // 提示缺少参数
        res.send({
            code: -1,
            msg: "缺少参数，请检查后再提交"
        })
    }
})

// 获取题目列表
// 地址：http://127.0.0.1:4000/api/exam/topic_list
// 请求：GET (可以在浏览器地址栏测试)
// 参数：eid
// 示例：http://127.0.0.1:4000/api/exam/topic_list
// 响应数据格式: json格式
router.get('/topic_list', async (req, res) => {
    let eid = req.query.eid;
    if(eid) {
        // 根据试卷ID （eid） 查询对应的题目列表
        await examModel.topic_list(eid)
        .then(
            data => {
                // 响应数据给前端
                res.send(data)
            },
            err => {
                res.send(err);
            }
        )
    }
    else {
        res.send({
            code: -1,
            msg: "缺少参数"
        })
    }
   
})



// ## 面试题
// 新增面试题
// 地址：http://127.0.0.1:4000/api/exam/question_add
// 请求：POST (不可以在浏览器地址栏测试)
// 参数：qid, text, question
// 示例：http://127.0.0.1:4000/api/exam/question_add
// 响应数据格式: json格式
router.post('/question_add', async (req, res) => {
    // 接收前端提交的参数
    let {hid, text, question} = req.body;
    // 判断参数是否有值
    if (hid && text && question) {
        // 执行数据库的操作
        await examModel.question_add(hid, text, question)
            .then(
                data => {
                    // 把模型中的处理结果响应给前端
                    res.send(data);
                }
            )
            .catch(
                err => {
                    res.send(err);
                }
            )
    }
    else {
        // 提示缺少参数
        res.send({
            code: -1,
            msg: "缺少参数，请检查后再提交"
        })
    }
})


// 获取面试题列表
// 地址：http://127.0.0.1:4000/api/exam/question_list
// 请求：GET (可以在浏览器地址栏测试)
// 参数：qid
// 示例：http://127.0.0.1:4000/api/exam/question_list
// 响应数据格式: json格式
router.get('/question_list', async (req, res) => {
    let hid = req.query.hid;
    console.log(hid)
    if(hid) {
        // 根据试卷ID （hid） 查询对应的题目列表
        await examModel.question_list(hid)
        .then(
            data => {
                // 响应数据给前端
                res.send(data)
            },
            err => {
                res.send(err);
            }
        )
    }
    else {
        res.send({
            code: -1,
            msg: "缺少参数"
        })
    }
   
})



//把当前这个路由挂在模块系统对象上
module.exports = router